(function (window) {
  // 传递进来的匿名函数 称作 excutor：执行器函数(同步)
  function Promise (excutor) {
    const PENDING = 'pending'
    const RESOLVED = 'resolved'
    const REJECTED = 'rejected'

    // 将当前promise对象保存起来
    const _this = this
    // 给promise对象指定status属性，初始值为pending
    this.status = PENDING
    // 给promise对象指定一个用于存储结果数据的属性
    this.data = null
    // 每个元素的结果 {onResolved() {}, onRejected() {}}
    this.callbacks = []

    function resolve (vlaue) {
      // 如果当前状态不是pending 直接结束
      if (_this.status !== PENDING) return
      // 将状态改为 resolved
      _this.status = RESOLVED
      // 保存value数据
      _this.data = vlaue
      // 如果有待执行的callback函数，立即异步执行回调函数 onResolved
      // 回调函数可能并不会第一时间被绑定
      if (_this.callbacks.length > 0) {
        // 放入队列 因为then函数中的回调是个异步方法
        setTimeout(() => {
          // callbacksObj 两个回调函数
          _this.callbacks.forEach(callbacksObj => {
            // 执行回调函数 还需要改变要返回的新的promise的状态
            callbacksObj.onResolved(vlaue)
          })
        })
      }

    }
    function reject (reason) {
      // 如果当前状态不是pending 直接结束
      if (_this.status !== PENDING) return
      // 将状态改为 rejected
      _this.status = REJECTED
      // 保存reason数据
      _this.data = reason
      // 如果有待执行的callback函数，立即异步执行回调函数 onRejected
      if (_this.callbacks.length > 0) {
        // 放入队列 因为then函数中的回调是个异步方法
        setTimeout(() => {
          // callbacksObj 两个回调函数
          _this.callbacks.forEach(callbacksObj => {
            callbacksObj.onRejected(reason)
          })
        })
      }
    }

    try {
      // 立即同步执行excutor
      excutor(resolve, reject)
    } catch (error) {
      // 如果执行器(使用者传入的回掉函数)抛出异常，promise对象变为rejected状态
      reject(error)
    }

  }

  /* 
  Promise上的原型方法
  */
  // 指定成功和失败的回调函数 返回一个新的promise对象  onResolved：成功的回调  onRejected：失败的回调
  Promise.prototype.then = function (onResolved, onRejected) {
    const _this = this

    // 返回一个新的promise对象
    // 我们需要判断 该调用那个状态下的回调函数
    return new Promise((resolve, reject) => {
      // 可能.then的时候 this.status 为别的状态
      if (_this.status === 'pending') {
        // 假设当前状态还是pending状态，将回调函数保存起来

        // 当状态为pending的时候，执行此步，存储状态改变后要执行的回调函数，当状态改变的时候，我们也会立马去执行存储起来的回调函数，回调函数的执行肯定要返回一个新的promise，所以需要把这个新的promise的状态改变掉，一遍供链上的下一个方法调取使用
        // 做出修改
        /*
         _this.callbacks.push({
          onResolved,
          onRejected
        }) 
        */

        _this.callbacks.push({
          // value 状态改变 传递的值 _self.data 也可以取到
          onResolved(value){ 
            try {
              //  针对错误异常
              const result = onResolved(value)
              if (result instanceof Promise) {
                result.then(resolve, reject)
              } else { // 非promise
                resolve(result)
              }
            } catch (error) {
              reject(error)
            }
          },
          onRejected(reason){
            try {
              // 上一次promise的状态 成功了就执行 onResolved 否则 失败执行 onRejected
              const result = onRejected(reason)
              // 如果是一个promise
              if (result instanceof Promise) {
                // 更为简洁处理
                result.then(resolve, reject)
              } else { // 非promise
                resolve(result)
              }
            } catch (error) {
              reject(error)
            }
          }
        })
      } else if (_this.status === 'resolved') {
        setTimeout(() => {
          /* 
            1. 如果抛出异常，return的promise就会失败，reason就是error
            2：如果回调函数返回非promise，return的promise就会成功，value就是返回的值
            3：如果回调函数返回的是promise，return的promise结果就是这个promise的结果
          */
          try {
            //  针对错误异常
            const result = onResolved(_this.data)
            // 如果是一个promise
            if (result instanceof Promise) {

              /* 
              // 取promise的结果
              // 怎么知道result成功了呢？只有使用then方法通过调用传入的两个回调函数才能知道
              result.then(
                // 当result成功时 让return的promise也成功
                value => resolve(value),
                // 当result失败时 让return的promise也失败
                reason => reject(reason)
              ) 
              */

              // 更为简洁处理
              result.then(resolve, reject)
            } else { // 非promise
              resolve(result)
            }
          } catch (error) {
            reject(error)
          }
        })
      } else { // rejected
        setTimeout(() => {
          /* 
            1. 如果抛出异常，return的promise就会失败，reason就是error
            2：如果回调函数返回非promise，return的promise就会成功，value就是返回的值
            3：如果回调函数返回的是promise，return的promise结果就是这个promise的结果
          */
          try {
            // 上一次promise的状态 成功了就执行 onResolved 否则 失败执行 onRejected
            const result = onRejected(_this.data)
            // 如果是一个promise
            if (result instanceof Promise) {
              // 更为简洁处理
              result.then(resolve, reject)
            } else { // 非promise
              resolve(result)
            }
          } catch (error) {
            reject(error)
          }
        })
      }
    })

  }

  // 指定失败的回调函数 返回一个新的promise对象
  Promise.prototype.catch = function (onRejected) {

  }

  /* 
    Promise函数对象上的方法
  */
  // 返回一个指定结果的promise对象
  Promise.resolve = function (vlaue) {

  }

  // 返回一个指定reason的失败的promise
  Promise.reject = function (reason) {

  }

  // 返回一个promise，只有当所有的promise都成功时才成功，否则只要有一个失败的就失败
  Promise.all = function (promises) {

  }

  // 返回一个promise，其结果由第一个完成的promise决定
  Promise.reason = function (promises) {

  }


  window.Promise = Promise
})(window)